/*
基于ckplayer的播放器
        主要支持流媒体播放
        因为ckplayer对于流媒体的支持不是很好，所以基于ckplayer的播放，重写控制控件


功能：
    1.new shplayer(obj);
    1.创建播放器：创建一个基于ckplayer的shplayer，显示控件，初始化回调方法
        参数：参数以对象的形式传值：obj = {id:'playerDiv',.....};
            1.控件载体，<div id="playerDiv"></div>，参数名称即为："playerDiv"
            2.初始化状态参数：如是自动播放，停止按钮的回调方法等
    2.播放器控制功能；
        2.1开始播放，暂停播放，停止播放，双击最大化，静音，等各种功能





功能流程：
    创建播放器；shplayer(obj);
        1.读取设置变量：
        2.初始化ckplayer:
            1.设置div大小，设置视频地址
            2.获取初始化ckplayer对象，并保存到变量中

*/

var javascriptPath = '';
!function() {
    var scriptList = document.scripts,
    thisPath = scriptList[scriptList.length - 1].src;
    javascriptPath = thisPath.substring(0, thisPath.lastIndexOf('/') + 1);
    // console.log(javascriptPath);
} ();



/*
author:shinion
date:2019-01-22

shplayer
*/

!(function(){

    // console.log(javascriptPath);


    var shplayer = function(obj){
        this.name = 'shplayer';//名称
        this.version = 'V 1.0.1';//版本号
        
        /*
        
        用户传入的基本参数，用于设定视频地址和显示基本消息
        
        */



       this.serverIp = '';//服务器ip
       this.port = 0;//端口号
       this.simNo = '';//通讯号
       this.channel = 0;//通道号
       this.plateNo = '';//车牌号
       this.stopBtnCallback = null;//定义停止按钮点击后回调方法
       this.mouseClickCallback = null;//定义单击播放器后的回调方法
       this.maxScreenCallback = null;//定义双击的回调方法
       
       
    //    this.parent = null;//定义父对象指针
       this.playerDiv = '';//播放器载体控件
       this.ckplayer = null;//初始化播放器对象为null
       

        this.windowWidth= 400;//播放器画面宽度
        this.windowHeight=300;//播放器画面高度
        this.minWidth = 150;//定义播放器最小宽度
        this.minHeight = 100;//定义播放器最小高度

        this.mouseClickTime = 0;//定义鼠标点击时间，用于判定双击事件
        this.mouseDbClickTime = 306;//定义双击事件的时间间隔，两次点击小于等于306即双击确定
        

        this.channelMsgId = null;//用于保存元件id，该元件显示信息为：通道信息
        this.channelMsgText = "";//用于保存通道信息
        this.cmdMsgId = null;//用于保存元件id，该元件显示的信息为：命令执行结果
        this.cmdMsgText = "";//用于保存命令执行结果信息
        this.cmdMsgTimerName = "cmdMsgTimer";//定时器名称




        this.paused = true;//定义播放器初始暂停状态为true
        this.muted = false;//定义静音初始状态为false


        /*
        
        设定基本变量，对播放器进行基本的设定
        
        */

        this.debug = false;//播放器是否调试，如果为true，则输出调试信息
        

        //如果变量存在，则读取
        if(!this.isUndefined(obj)){

            this.out("第 317 次测试");
        
            if(!this.format(obj)){
                this.error("格式化参数失败");  
                return;
            }
            if(!this.setSizes()){
                this.error("播放器画面太小，生成失败");
                return;
            }

            if(!this.createCkplayer()){
                this.error("创建ckplayer播放器失败");
                return ;
            }

            //隐藏ckplayer原有控件
            // this.hideCkplayerControl();
            

            //显示通道信息
            // this.showChannelMsg();


            this.out("创建播放器成功");
            // this.out(this);//测试输出方法

            
            return this;
        }
    };

    
    shplayer.prototype = {
        //格式化输入数据
        format:function(obj){
            return this.standardization(obj,this);
        },
        //初始化方法1。
        //获取设置播放器画面和控制栏的大小
        setSizes:function(){
            try {
                //首先获取控件的长宽信息
                if(this.playerDiv == '')
                    return false;
                var divTemp = $('#'+this.playerDiv);
                if(this.isUndefined(divTemp))
                    return false;
                
                var widthTemp = parseInt(divTemp.css('width'));
                if(isNaN(widthTemp))
                    widthTemp = 0;
                var heightTemp =parseInt(divTemp.css('height'));
                if(isNaN(heightTemp))
                    heightTemp = 0;

                //如果画面太小，设置最小尺寸
                if(widthTemp < this.minWidth){
                    widthTemp = this.minWidth;
                    divTemp.css("width",widthTemp);
                }
                if(heightTemp < this.minHeight){
                    heightTemp = this.minHeight;
                    divTemp.css("height",heightTemp);
                }
                
                // this.out("重新设置最小化,widthTemp = "+widthTemp+",heightTemp = "+heightTemp);
                

                //设置播放器画面的宽高
                this.windowWidth = this.widthTemp;//画面宽高
                this.windowHeight = this.heightTemp

                return true;
            } catch (error) {
                this.error("设置播放器大小失败："+error);
                return false;
            }

        },
        
        //初始方法2,
        //初始化播放器画面
        createCkplayer:function(){
            var me = this;
            try {
                //添加控件
                var playerDivTemp = "#"+this.playerDiv;
                var url = this.initUrl();
                //添加事件
                this.addEvent($(playerDivTemp));
                //获取ckplayer对象
                var player = this.getCkplayer(playerDivTemp,url);
                //添加并保存相关变量
                this.ckplayer = player;

                //添加监听方法
                // this.addListener(this.ckplayer);
                //重置大小
                var obj = $(playerDivTemp);
                if(!this.isUndefined(obj)){
                    obj.css("width",this.windowWidth);
                    obj.css("height",this.windowHeight);
                }
                this.out("创建ckplayer成功");
                return true;
            } catch (error) {
                this.error("创建ckplayer播放器失败："+error);
                return false;
            }
        },

        //初始化方法2-1
        //获取ckplayer对象
        getCkplayer:function(containerTemp,url){
            var videoObjectTemp = {
                container:containerTemp,
                variable:'player',
                video:url,
                // doubleClick:false,//屏蔽双击全屏
                // autoplay:false,//自动播放,默认是不自动播放，如果需要播放，则在初始化播放器状态中修改
                // loaded:'loadedCallback',//加载完成后调用
            };
            var player = new ckplayer(videoObjectTemp);
            return player;
        },

        //获取播放器的视频地址
        initUrl:function(){
            return ("rtmp://"+this.serverIp+":"+this.port+"/live/"+this.simNo+"_"+this.channel);
            // return "http://192.168.6.77:8080/movie/xihongshi.mp4";
            // return "rtmp://192.168.6.191:19350/live/123_2";
        },

        //设置播放器的新视频地址
        setNewVideoUrl:function(url,autoplayFlg){
            // this.out("播放器开始重置地址url="+url+",autoplayFlg="+autoplayFlg);
            var ckplayer = this.ckplayer;
            // this.out(ckplayer);
            if(this.isUndefined(ckplayer))
                return;
            if(typeof(ckplayer.V.newVideo) == "function"){
                ckplayer.newVideo({video:url,autoplay:autoplayFlg});
            }
        },
        //获取播放器的当前地址
        getUrl:function(){
            var url = this.ckplayer.vars.video;
            if(this.isUndefined(url))
                url = "";
            return url;
        },

        //添加事件
        addEvent: function (playerDivTemp) {
            var me = this;
            var objTemp = playerDivTemp;
            // console.log(objTemp);
            if (!this.isUndefined(objTemp)) {
                //鼠标单击事件
                objTemp.mousedown(function (event) {
                    me.mouseClickFun(event);
                });
            }
        },
        //添加监听方法
        addListener:function(ckplayerTemp){
            var me = this;
            var timerNameTemp = 'addListener'+Math.floor(Math.random()*1000+3000);
            var num = 0;
            var addFlg = false;//标记是否添加成功


            var timeHandler = function(time){
                me.out(time);
                me.showPlayStatusInfo(time);
            };

            $(document).everyTime("300ms",timerNameTemp,function(){
                num ++;
                if(num > 10){
                    me.out("添加监听时间方法定时器，循环超过10次，停止定时");
                    $(document).stopTime(timerNameTemp);
                    return;
                }
                if (me.isUndefined(ckplayerTemp))
                    return;

                //添加监听
                if (ckplayerTemp.playerType == "flashplayer") {
                    if (typeof (ckplayerTemp.V.addListener) == "function") {
                        ckplayerTemp.V.addListener('time', timeHandler);
                        addFlg = true;
                    }
                } else {
                    if (typeof (ckplayerTemp.addListener) == "function") {
                        ckplayerTemp.addListener('time', timeHandler);
                        addFlg = true;
                    }
                }
                //添加成功
                if(addFlg){
                    me.out("添加监听时间方法成功");
                    $(document).stopTime(timerNameTemp);
                    return;
                }

            });
            
        },
        

        //隐藏cklayer播放器控件
        hideCkplayerControl:function(){
            var me = this;
            var timerNameTemp = 'hideCkplayerControl'+Math.floor(Math.random()*1000+1000);
            var num = 0;
            $(document).everyTime("300ms",timerNameTemp,function(){
                num ++;
                if(num > 10){
                    me.out("隐藏控件定时器，循环超过10次，停止定时");
                    $(document).stopTime(timerNameTemp);
                    return;
                }
                if (me.isUndefined(me.ckplayer))
                    return;
                if(me.ckplayer.V){

                    var funTemp = me.ckplayer.V.changeControlBarShow;
                    // me.out(funTemp+',num+'+num);
                    if (!me.isUndefined(funTemp)){
                        if (typeof (funTemp) == "function") {
                            // me.out("ckplayer.V.changeControlBarShow")
                            funTemp(false);
                            $(document).stopTime(timerNameTemp);
                            return;
                        }
                    }
                }
            });
            
        },



        //获取当前播放器播放状态
        getPlayStatus:function(){
            if(typeof(this.ckplayer.getMetaDate) == "function"){
                var paused = this.ckplayer.getMetaDate()['paused'];
                // this.out("metaData[paused] = "+paused);
                if(!this.isUndefined(paused))
                    return paused;
            }


            var paused2 = this.ckplayer.V.paused;
            // this.out("ckplayer.V.paused = " + paused2);
            if (!this.isUndefined(paused2))
                return paused2;

            var paused3 = this.ckplayer.paused;
            // this.out("ckplayer.paused = " + paused3);
            if (!this.isUndefined(paused3))
                return paused3;
            
                // this.out("shplayer.paused = " + this.paused);
            return this.paused;
        },

        
        /*
        开始视频
        */
        videoPlay:function(){
            var ckplayer = this.ckplayer;
            if (this.isUndefined(ckplayer))
                return;
            if (ckplayer.playerType == 'flashplayer') {
                if (typeof (ckplayer.V.videoPlay) == "function") {
                    ckplayer.V.videoPlay();
                    this.paused = false;
                }
            } else {
                ckplayer.videoPlay();
                this.paused = false;
            }
        },

        /*
        暂停视频
        */
        videoPause: function () {
            var ckplayer = this.ckplayer;
            if (this.isUndefined(ckplayer))
                return;
            if (ckplayer.playerType == 'flashplayer') {
                if (typeof (ckplayer.V.videoPause) == "function") {
                    ckplayer.V.videoPause();
                    this.paused = true;
                }
            } else {
                ckplayer.videoPause();
                this.paused = true;
            }
        },

        /*
        获取播放器状态并显示信息
        */
        showPlayStatusInfo:function(time){
            var me = this;
            me.out(me);
            //显示状态信息
            // var startTimeTemp = parseInt(time);//定义开始时间
            var startTimeTemp = Math.floor(time);//定义开始时间
            var endTimeTemp = 0;//定义结束时间
            var ckplayerTemp = me.ckplayer;
            var metaData = null;
            if (typeof (ckplayerTemp.getMetaDate) == "function") {
                metaData = ckplayerTemp.getMetaDate();

            } else if (typeof (ckplayerTemp.V.getMetaDate) == "function") {
                metaData = ckplayerTemp.V.getMetaDate();

            }
            if (!me.isUndefined(metaData)) {
                endTimeTemp = metaData['duration'];
                // me.out("加载的时间 = " + me.getTimeStr(metaData['loadTime']) + " , 总时间 = "+me.getTimeStr(metaData['duration']));
            }
            // me.showTimeMsg(me.getTimeStr(startTimeTemp), me.getTimeStr(endTimeTemp));
            
        },


        /*
        鼠标点击事件方法
            this 代表shplayer
        */

        mouseClickFun:function(event){
            var me = this;
            // this.out(this);
            try {
                
                //调用回调方法
                if(!this.isUndefined(this.mouseClickCallback)){
                    if(typeof(this.mouseClickCallback) == "function"){
                        this.mouseClickCallback(this.channel-1);
                        // this.out("调用鼠标单击按钮回调方法");
                    }
                }
                //判断是否符合双击标准
                var now = new Date();
                if (me.mouseClickTime == 0) {
                    me.mouseClickTime = now.getTime();
                } else {
                    var temp = now.getTime() - me.mouseClickTime;
                    // me.out("时间间隔="+temp);
                    me.mouseClickTime = now.getTime();
                    if (temp <= me.mouseDbClickTime) {
                        //符合双击条件，单画面最大化或者还原最大化画面
                        me.setMaxScreen();
                    }
                }

                
            } catch (error) {
                me.error("鼠标点击事件中发生错误："+error);
            }
        },

        /*
        屏幕最大化事件
        */
        setMaxScreen: function () {
            if (!this.isUndefined(this.maxScreenCallback)) {
                if (typeof (this.maxScreenCallback) == "function") {
                    this.maxScreenCallback();
                    // this.out("调用屏幕最大化回调方法");
                }
            }
            // this.out("屏幕最大化");
        },



        /*
        显示通道信息
            setFlg为true表示赋值channelMsg并显示通道信息，为false表示不赋值，直接显示
        */
        showChannelMsg:function(channelMsg,setFlg){
            var me = this;
            try {
                if(setFlg){//如果true，则赋值
                    me.channelMsgText = channelMsg;
                }
                if(me.channelMsgText == ""){
                    me.deleteChannelElement();
                    return;//如果通道信息为空，则删除元件后退出
                }
                var num = 0;//定义次数，超过10次，退出
                var timerNameTemp = 'showChannelMsg'+Math.floor(Math.random()*1000);
                $(document).everyTime("300ms", timerNameTemp, function () {
                    num++;
                    // me.out("定时器名称="+timerNameTemp);
                    if(num > 10){
                        me.out("显示通道信息定时器，循环超过10次，停止定时");
                        $(document).stopTime(timerNameTemp);
                        return;
                    }

                    var ckplayer = me.ckplayer;
                    // me.out(ckplayer);
                    if (me.isUndefined(ckplayer))
                        return;



                    var msg = me.channelMsgText;
                    var attribute = me.getTextElementObj(1, 1, msg);
                    if(ckplayer.playerType = "flashplayer"){
                        if (ckplayer.V && typeof (ckplayer.V.addElement) == "function"){
                            if(me.channelMsgId != null){
                                ckplayer.V.deleteElement(me.channelMsgId);
                                me.channelMsgId = null;
                            }
                            me.channelMsgId = ckplayer.V.addElement(attribute);
                            $(document).stopTime(timerNameTemp);
                             me.out("显示通道信息成功");
    
                        }
                        // ckplayer.CB['timeText'].innerHTML = "shinion";
                    }

                    return;
                    
                });

            } catch (error) {
                me.error("显示通道信息错误："+error);
            }
        },

        

        //删除元件
        deleteChannelElement:function(){
            var me = this;
            var ckplayerTemp = me.ckplayer;
            if (me.isUndefined(ckplayerTemp)){
                return;
            }
            if(this.isUndefined(ckplayerTemp))
                return;
            if(ckplayerTemp.playerType == "flashplayer"){
                if(ckplayerTemp.V && typeof(ckplayerTemp.V.deleteElement) == "function"){
                    if(me.channelMsgId != null){
                        ckplayerTemp.V.deleteElement(me.channelMsgId);
                        me.channelMsgId = null;
                    }
                    me.out("删除通道信息元件成功")
                }
            }
        },


        /*
        显示命令执行结果
            不需要关心命令执行结果
            当调用本方法时，首先查看定时器是否已经执行
                如果已经执行，那么停止前一个定时器，重新开始计时
                如果没有执行，那么开启定时器
                
                定时器重复10次，每次都是删除原有的元件信息，新建信息元件并显示
                    如果重复次数达到10次，那么停止计时器，删除元件
        */
        showCmdMsg: function (msg) {
            var me = this;
            try {
                me.cmdMsgText = msg;//赋值msg
                // me.out("命令执行结果信息："+me.cmdMsgText);
                // me.out("命令执行结果显示定时器名称："+me.cmdMsgTimerName);
                var num = 0;//定义次数，超过10次，退出
                //关闭前一个定时器
                if(me.cmdMsgTimerName != "cmdMsgTimer"){
                    $(document).stopTime(me.cmdMsgTimerName);
                }
                me.cmdMsgTimerName = 'cmdMsgTimer' + Math.floor(Math.random() * 1000 + 4000);
                //开启新的定时器
                $(document).everyTime('500ms',me.cmdMsgTimerName, function () {
                    num++;
                    // me.out("定时器名称=" + me.cmdMsgTimerName);
                    if (num > 6) {
                        me.out("显示命令执行结果定时器，循环超过6次，停止定时");
                        $(document).stopTime(me.cmdMsgTimerName);
                        me.deleteCmdElement(me.ckplayer);
                        // console.log("显示执行结果定时器达到10次，删除元件");
                        // console.log(me.cmdMsgId);
                        return;
                    }

                    if(!me.addCmdElement(me.ckplayer,me.getTextElementObj(150,1,me.cmdMsgText)))
                        me.out("显示命令执行结果失败");
                    
                });
            } catch (error) {
                me.error("显示命令执行结果错误：" + error);
            }
        },

        //获取元件对象
        getTextElementObj:function(x,y,msg){
            //获取元件
            var attribute = {	list: [ //list=定义元素列表
                {
                   type: 'text', //说明是文本
                   text: msg, //文本内容
                   color: '0xFFFFFF', //文本颜色
                   size: 14, //文本字体大小，单位：px
                   font: '"Microsoft YaHei", YaHei, "微软雅黑",', //字体
                   leading: 30, //文字行距
                   alpha: 0.5, //文本透明度(0-1)
                   paddingLeft: 5, //文本内左边距离
                   paddingRight: 5, //文本内右边距离
                   paddingTop: 0, //文本内上边的距离
                   paddingBottom: 0, //文本内下边的距离
                   marginLeft: 0, //文本离左边的距离
                   marginRight: 0, //文本离右边的距离
                   marginTop: 0, //文本离上边的距离
                   marginBottom: 0, //文本离下边的距离
                   backgroundColor: '0xFF0000', //文本的背景颜色
                   backAlpha: 0, //文本的背景透明度(0-1),0为全透明，1为不透明
                   backRadius: 0, //文本的背景圆角弧度,0为直边长方形，100为圆弧状
                }
               ],
               x: x, //元件x轴坐标，注意，如果定义了position就没有必要定义x,y的值了，支持数字和百分比
               y: y, //元件y轴坐标
               //position:[1,1],//位置[x轴对齐方式（0=左，1=中，2=右），y轴对齐方式（0=上，1=中，2=下）
               alpha: 1, //元件的透明度
               backgroundColor: '0xFF0000', //元件的背景色
               backAlpha: 0, //元件的背景透明度(0-1)
               backRadius: 0, //元件的背景圆角弧度
            //    clickEvent: clickEventName,
           }
           return attribute;
        },

        //添加元件信息
        addCmdElement:function(ckplayerTemp,attribute){
            var me = this;
            if(this.isUndefined(ckplayerTemp))
                return;
            if(ckplayerTemp.playerType == "flashplayer"){
                if(ckplayerTemp.V && typeof(ckplayerTemp.V.addElement) == "function"){
                    if(me.cmdMsgId != null){
                        ckplayerTemp.V.deleteElement(me.cmdMsgId);
                        // me.out("删除成功");
                        me.cmdMsgId = null;
                        // me.out("上一元件id："+me.cmdMsgId);
                    }
                    me.cmdMsgId = ckplayerTemp.V.addElement(attribute);
                    // me.out("me.cmdMsgId:"+me.cmdMsgId);
                    return true;
                }
            }
            return false;
        },
        //删除命令信息元件
        deleteCmdElement:function(ckplayerTemp){
            var me = this;
            if(this.isUndefined(ckplayerTemp))
                return;
            if(ckplayerTemp.playerType == "flashplayer"){
                if(ckplayerTemp.V && typeof(ckplayerTemp.V.addElement) == "function"){
                    if(me.cmdMsgId != null){
                        ckplayerTemp.V.deleteElement(me.cmdMsgId);
                        me.cmdMsgId = null;
                    }
                }
            }
        },




        //
        /*
        公共方法，通过时间获取特定格式的字符串
            返回格式： '12:01:93'
        */
        getTimeStr:function(time){
            var timeTemp = parseInt(time);
            if (isNaN(timeTemp))
                return '00:00:00';
            var secondsTemp = 0;
            var minuteTemp = 0;
            var hourTemp = 0;

            //获取值
            secondsTemp = Math.floor(timeTemp % 60);//获取秒
            if(timeTemp >= 60){
                minuteTemp = Math.floor(timeTemp / 60);//获取分钟
                if(minuteTemp >= 60){
                    var temp = minuteTemp;
                    minuteTemp = Math.floor(temp % 60);//获取分钟
                    hourTemp = Math.floor(temp / 60);//获取小时
                }
            }
            
            //设置格式
            secondsTemp = secondsTemp + '';
            if (secondsTemp.length == 1)
                secondsTemp = '0' + secondsTemp;
            minuteTemp = minuteTemp + '';
            if (minuteTemp.length == 1)
                minuteTemp = '0' + minuteTemp;
            hourTemp = hourTemp + '';
            if (hourTemp.length == 1)
                hourTemp = '0' + hourTemp;

            return (hourTemp+':'+minuteTemp+':'+secondsTemp);
        },
        //公用方法,从f读取数据,并标准化输入到t
        //
        standardization:function(f,t){
            try {
                var temp ;
                for(temp in f){
                    var type = typeof(t[temp]);
                    switch(type){
                        case 'number':
                            t[temp] = parseFloat(f[temp]);
                        break;
                        default:
                            t[temp] = f[temp];
                        break;
                    }
                }
                // this.out("standardization success");
                return true;
            } catch (error) {
                this.error("标准化输入数据错误："+error);
                return false;
            }
        },

        //公共方法,输出信息
        //
        out:function(msg){
            if(this.debug)
                console.log(msg);
        },

        //公共方法,输出错误
        //
        error:function(error){
            console.error(error);
        },

        //公共方法,判断是否为undefined

        isUndefined:function(value){
            try {
                if (value == 'undefined' || value == undefined || value == null) {
                    return true;
                }
            } catch(event) {
                this.out(event);
            }
            return false;
        }
    };

    window.shplayer = shplayer;
})();




